package com.allm.ai.common.factory.impl;

import com.allm.ai.common.entity.AiModel;
import com.allm.ai.common.factory.ChatModelCreator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.openai.OpenAiChatModel;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.stereotype.Component;

/**
 * Kimi ChatModel 创建器
 * 根据数据库中的 AiModel 配置自动创建 ChatModel
 * 使用 spring-ai-starter-model-openai 提供的 OpenAI 兼容 API
 */
@Slf4j
@Component
@ConditionalOnClass({OpenAiApi.class, OpenAiChatModel.class})
public class OpenAiChatModelCreator implements ChatModelCreator {
    
    @Override
    public String getServiceProvider() {
        return "OpenAi";
    }
    
    @Override
    public ChatModel createChatModel(AiModel aiModel) throws Exception {
        log.info("自动创建 OpenAi ChatModel: {}", aiModel.getRequestModelName());
        
        if (!validateConfig(aiModel)) {
            throw new IllegalArgumentException("OpenAi 模型配置无效: " + aiModel.getRequestModelName());
        }
        
        try {
            // 根据 AiModel 配置自动创建 ChatModel
            return createOpenAiModel(aiModel);
        } catch (Exception e) {
            log.error("自动创建 OpenAi ChatModel 失败: {}", aiModel.getRequestModelName(), e);
            throw new RuntimeException("创建 OpenAi ChatModel 失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 根据 AiModel 配置创建 OpenAi ChatModel
     * 使用 OpenAI 兼容的 API
     */
    private ChatModel createOpenAiModel(AiModel aiModel) throws Exception {
        // 1. 创建 OpenAI API 客户端（OpenAi使用OpenAI兼容格式）
        OpenAiApi openAiApi = createOpenAiApi(aiModel);
        
        // 2. 根据 AiModel 配置构建选项
        OpenAiChatOptions options = createKimiOptions(aiModel);
        
        // 3. 创建 OpenAiChatModel 实例
        return OpenAiChatModel.builder()
                .openAiApi(openAiApi)
                .defaultOptions(options)
                .build();
    }
    
    /**
     * 创建 OpenAI API 客户端
     */
    private OpenAiApi createOpenAiApi(AiModel aiModel) {
        // 设置 OpenAi 端点
        String baseUrl = aiModel.getApiEndpoint();
        if (baseUrl == null || baseUrl.trim().isEmpty()) {
            baseUrl = "https://api/v1"; // 默认 OpenAi 端点
        }
        
        // 确保 URL 格式正确
        if (!baseUrl.endsWith("/")) {
            baseUrl += "/";
        }
        
        log.info("创建 OpenAI API 客户端，端点: {}", baseUrl);
        
        // 使用 OpenAiApi 的 Builder 模式
        return OpenAiApi.builder()
                .baseUrl(baseUrl)
                .apiKey(aiModel.getApiKey())
                .build();
    }
    
    /**
     * 创建 OpenAI 选项
     */
    private OpenAiChatOptions createKimiOptions(AiModel aiModel) {
        OpenAiChatOptions.Builder optionsBuilder = OpenAiChatOptions.builder()
                .model(aiModel.getRequestModelName());
        
        // 设置温度参数
        if (aiModel.getTemperature() != null) {
            optionsBuilder.temperature(aiModel.getTemperature().doubleValue());
        }

        // 设置最大令牌数
        if (aiModel.getMaxTokens() != null) {
            optionsBuilder.maxTokens(aiModel.getMaxTokens());
        }

        // 关键：为推理模型添加特殊配置
        if (isReasoningModel(aiModel)) {
            log.info("检测到OpenAI推理模型，启用思考过程输出: {}", aiModel.getRequestModelName());
            
            // 推理模型特殊配置
            optionsBuilder.reasoningEffort(getServiceProvider())
                .temperature(aiModel.getTemperature().doubleValue())  // 低温度确保稳定的推理
                .maxTokens(aiModel.getMaxTokens())   // 足够的令牌数容纳思考过程
                .topP(0.9);        // 设置top_p参数
            
            // 如果Kimi API支持，可以添加其他推理相关参数
            // 例如：reasoning: true, show_reasoning: true 等
        }
        
        return optionsBuilder.build();
    }
    
    @Override
    public boolean supportsStreaming() {
        return true;
    }
    
    @Override
    public boolean validateConfig(AiModel aiModel) {
        boolean baseValid = ChatModelCreator.super.validateConfig(aiModel);
        if (!baseValid) {
            return false;
        }
        
        // Kimi 特定验证
        String endpoint = aiModel.getApiEndpoint();
        if (endpoint != null && !endpoint.contains("openai.com")) {
            log.warn("openAI 模型的端点可能不正确: {}", endpoint);
        }
        
        return true;
    }
}
